package com.xky.example_student.controller.score;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.xky.example_student.annotation.RequirePermission;
import com.xky.example_student.entity.Result;
import com.xky.example_student.entity.Score;
import com.xky.example_student.entity.ScoreStatistics;
import com.xky.example_student.entity.Teacher;
import com.xky.example_student.entity.Student;
import com.xky.example_student.service.ScoreService;
import com.xky.example_student.service.TeacherService;
import com.xky.example_student.service.StudentService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import jakarta.servlet.http.HttpServletRequest;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.stream.Collectors;

@Slf4j
@RestController
@RequestMapping("/api/score")
@Tag(name = "成绩信息管理")
public class ScoreController {

    private final ScoreService scoreService;
    private final TeacherService teacherService;
    private final StudentService studentService;

    public ScoreController(ScoreService scoreService, TeacherService teacherService, StudentService studentService) {
        this.scoreService = scoreService;
        this.teacherService = teacherService;
        this.studentService = studentService;
    }

    /**
     * 获取当前用户角色和学号
     * @param request
     * @return 用户信息数组 [角色, 学号]
     */
    private String[] getCurrentUserInfo(HttpServletRequest request) {
        // 从请求头或session中获取用户信息
        String userRole = request.getHeader("User-Role");
        String userStuId = request.getHeader("User-StuId");
        
        log.info("接收到的用户角色: {}", userRole);
        log.info("接收到的用户学号: {}", userStuId);
        
        // 安全验证：检查请求头是否包含非法字符
        if (userRole != null && !isValidRole(userRole)) {
            log.warn("检测到非法的用户角色: {}", userRole);
            userRole = "student"; // 默认为学生角色
        }
        
        if (userStuId != null && !isValidStuId(userStuId)) {
            log.warn("检测到非法的用户学号: {}", userStuId);
            userStuId = null;
        }
        
        // 如果没有从请求头获取到角色，默认为管理员（用于兼容性）
        if (userRole == null || userRole.trim().isEmpty()) {
            log.warn("未找到用户角色信息，默认为管理员");
            userRole = "admin";
        }
        
        // 对于userStuId，如果为空则保持null，不设置默认值
        if (userStuId != null && userStuId.trim().isEmpty()) {
            userStuId = null;
        }
        
        log.info("最终使用的用户角色: {}", userRole);
        log.info("最终使用的用户学号: {}", userStuId);
        
        return new String[]{userRole, userStuId};
    }
    
    /**
     * 验证用户角色是否合法
     */
    private boolean isValidRole(String role) {
        if (role == null) return false;
        return role.matches("^(admin|teacher|student)$");
    }
    
    /**
     * 验证学号/工号是否合法（只允许数字和字母）
     */
    private boolean isValidStuId(String stuId) {
        if (stuId == null) return false;
        return stuId.matches("^[a-zA-Z0-9]{1,20}$");
    }

    /**
     * 检查权限：学生只能查看自己的成绩
     * @param request
     * @param targetStuId 目标学号
     * @return 是否有权限
     */
    private boolean hasPermission(HttpServletRequest request, Integer targetStuId) {
        String[] userInfo = getCurrentUserInfo(request);
        String userRole = userInfo[0];
        String userStuId = userInfo[1];
        
        // 管理员可以查看所有成绩
        if ("admin".equals(userRole)) {
            return true;
        }
        
        // 学生只能查看自己的成绩
        if ("student".equals(userRole)) {
            return userStuId.equals(String.valueOf(targetStuId));
        }
        
        return false;
    }

    /**
     * 学生分数信息的保存
     * @param score
     * @return
     */
    @PostMapping("/save")
    @Operation(summary = "保存学生分数信息")
    @RequirePermission(value = {"teacherScore", "teacherAdmin"}, message = "您暂时没有录入成绩的权限")
    public Result<Score> save(@RequestBody Score score, HttpServletRequest request){
        log.info("成绩保存{}",score);
        
        // 获取当前用户信息
        String[] userInfo = getCurrentUserInfo(request);
        String userRole = userInfo[0];
        String userStuId = userInfo[1];
        
        // 管理员可以录入所有成绩
        if ("admin".equals(userRole)) {
            log.info("管理员正在录入成绩: 学号={}, 姓名={}", score.getStuId(), score.getStuName());
        } else if ("teacher".equals(userRole)) {
            // 教师只能录入自己班级学生的成绩
            if (userStuId == null || userStuId.trim().isEmpty()) {
                log.error("教师用户未提供工号信息");
                return Result.error("请登录以录入成绩");
            }
            
            try {
                // 1. 检查教师所教班级
                LambdaQueryWrapper<Teacher> teacherQuery = new LambdaQueryWrapper<>();
                teacherQuery.eq(Teacher::getTeaId, userStuId);
                Teacher teacher = teacherService.getOne(teacherQuery);
                
                if (teacher == null) {
                    log.error("未找到工号为 {} 的教师信息", userStuId);
                    return Result.error("未找到教师信息，请联系管理员");
                }
                
                String teacherClass = teacher.getTeaCalss();
                if (teacherClass == null || teacherClass.trim().isEmpty()) {
                    log.warn("教师 {} 未设置所教班级", userStuId);
                    return Result.error("您未设置所教班级，请联系管理员配置");
                }
                
                // 2. 检查要录入成绩的学生是否属于该教师的班级
                LambdaQueryWrapper<Student> studentQuery = new LambdaQueryWrapper<>();
                studentQuery.eq(Student::getStuId, score.getStuId().toString());
                Student student = studentService.getOne(studentQuery);
                
                if (student == null) {
                    log.error("未找到学号为 {} 的学生信息", score.getStuId());
                    return Result.error("未找到该学生信息");
                }
                
                if (!teacherClass.equals(student.getStuClass())) {
                    log.warn("教师 {} (班级: {}) 尝试录入其他班级学生 {} (班级: {}) 的成绩", 
                        userStuId, teacherClass, score.getStuId(), student.getStuClass());
                    return Result.error("您只能录入本班级学生的成绩");
                }
                
                log.info("教师 {} 正在录入本班级学生成绩: 学号={}, 姓名={}", userStuId, score.getStuId(), score.getStuName());
            } catch (Exception e) {
                log.error("验证教师录入权限时发生错误", e);
                return Result.error("权限验证失败：" + e.getMessage());
            }
        } else {
            log.warn("非授权用户尝试录入成绩: 角色={}", userRole);
            return Result.error("您没有权限录入成绩");
        }
        
        boolean isSave = scoreService.save(score);
        
        // 成功保存后更新学分绩
        if (isSave) {
            scoreService.updateStudentCreditScores(score.getStuId());
        }
        
        return isSave ? Result.success() : Result.error("保存失败");
    }

    /**
     * 删除id为xx的学生成绩信息
     *
     * @param id
     * @return
     */
    @DeleteMapping("/removeById")
    @Operation(summary = "删除学生成绩信息")
    @RequirePermission(value = {"teacherScore", "teacherAdmin"}, message = "您暂时没有删除成绩的权限")
    public Result removeById(@RequestParam Integer id, HttpServletRequest request){
        log.info("删除id为{}的学生成绩信息",id);
        
        // 获取当前用户信息
        String[] userInfo = getCurrentUserInfo(request);
        String userRole = userInfo[0];
        
        // 管理员和有teacherAdmin权限的教师可以删除成绩
        if ("admin".equals(userRole)) {
            log.info("管理员正在删除成绩: ID={}", id);
        } else if ("teacher".equals(userRole)) {
            log.info("教师正在删除成绩: ID={}", id);
        } else {
            log.warn("非授权用户尝试删除成绩: 角色={}", userRole);
            return Result.error("您没有权限删除成绩");
        }
        
        boolean removeById = scoreService.removeById(id);
        return removeById ? Result.success() : Result.error("删除id为"+id+"的学生成绩失败");
    }

    /**
     * 删除全部的学生成绩信息
     * @return
     */
    @DeleteMapping("/remove")
    @Operation(summary = "删除全部的学生信息")
    @RequirePermission(value = {"teacherScore", "teacherAdmin"}, message = "您暂时没有删除所有成绩的权限")
    public Result<Boolean> removeAll(HttpServletRequest request){
        log.info("删除全部的学生信息");
        
        // 获取当前用户信息
        String[] userInfo = getCurrentUserInfo(request);
        String userRole = userInfo[0];
        
        // 只有管理员和有特殊权限的教师可以删除所有成绩（高风险操作）
        if ("admin".equals(userRole)) {
            log.warn("管理员正在执行高风险操作：删除所有成绩");
        } else if ("teacher".equals(userRole)) {
            log.warn("教师正在执行高风险操作：删除所有成绩");
        } else {
            log.error("非授权用户尝试删除所有成绩: 角色={}", userRole);
            return Result.error("您没有权限进行此高风险操作");
        }
        
        LambdaQueryWrapper<Score> scoreLambdaQueryWrapper = new LambdaQueryWrapper<>();
        boolean remove = scoreService.remove(scoreLambdaQueryWrapper);
        return remove ? Result.success() : Result.error("删除学生成绩信息失败");
    }

    /**
     * 根据id更新学生成绩信息
     * @param score
     * @return
     */
    @PostMapping("/update")
    @Operation(summary = "更新学生成绩信息")
    @RequirePermission(value = {"teacherScore", "teacherAdmin"}, message = "您暂时没有修改成绩的权限")
    public Result<Boolean> update(@RequestBody Score score, HttpServletRequest request){
        log.info("修改学生成绩信息{}",score);
        
        // 获取当前用户信息
        String[] userInfo = getCurrentUserInfo(request);
        String userRole = userInfo[0];
        String userStuId = userInfo[1];
        
        // 管理员可以修改所有成绩
        if ("admin".equals(userRole)) {
            log.info("管理员正在修改成绩: {}", score.getId());
        } else if ("teacher".equals(userRole)) {
            // 教师只能修改自己班级学生的成绩
            if (userStuId == null || userStuId.trim().isEmpty()) {
                log.error("教师用户未提供工号信息");
                return Result.error("请登录以修改成绩");
            }
            
            try {
                // 1. 检查教师所教班级
                LambdaQueryWrapper<Teacher> teacherQuery = new LambdaQueryWrapper<>();
                teacherQuery.eq(Teacher::getTeaId, userStuId);
                Teacher teacher = teacherService.getOne(teacherQuery);
                
                if (teacher == null) {
                    log.error("未找到工号为 {} 的教师信息", userStuId);
                    return Result.error("未找到教师信息，请联系管理员");
                }
                
                String teacherClass = teacher.getTeaCalss();
                if (teacherClass == null || teacherClass.trim().isEmpty()) {
                    log.warn("教师 {} 未设置所教班级", userStuId);
                    return Result.error("您未设置所教班级，请联系管理员配置");
                }
                
                // 2. 检查要修改成绩的学生是否属于该教师的班级
                LambdaQueryWrapper<Student> studentQuery = new LambdaQueryWrapper<>();
                studentQuery.eq(Student::getStuId, score.getStuId().toString());
                Student student = studentService.getOne(studentQuery);
                
                if (student == null) {
                    log.error("未找到学号为 {} 的学生信息", score.getStuId());
                    return Result.error("未找到该学生信息");
                }
                
                if (!teacherClass.equals(student.getStuClass())) {
                    log.warn("教师 {} (班级: {}) 尝试修改其他班级学生 {} (班级: {}) 的成绩", 
                        userStuId, teacherClass, score.getStuId(), student.getStuClass());
                    return Result.error("您只能修改本班级学生的成绩");
                }
                
                log.info("教师 {} 正在修改本班级学生成绩: {}", userStuId, score.getId());
            } catch (Exception e) {
                log.error("验证教师修改权限时发生错误", e);
                return Result.error("权限验证失败：" + e.getMessage());
            }
        } else {
            log.warn("非授权用户尝试修改成绩: 角色={}", userRole);
            return Result.error("您没有权限修改成绩");
        }
        
        boolean update = scoreService.updateById(score);
        
        // 成功更新后更新学分绩
        if (update) {
            scoreService.updateStudentCreditScores(score.getStuId());
        }
        
        return update ? Result.success() : Result.error("学生成绩信息更新失败");
    }

    /**
     * 查询id为xx的学生成绩信息
     * @param id
     * @return
     */
    @GetMapping("/listById")
    @Operation(summary = "查询id为xx的学生成绩信息")
    public Result<List<Score>> listById(@RequestParam Integer id){
        log.info("查看id为{}的学生成绩信息",id);
        LambdaQueryWrapper<Score> scoreLambdaQueryWrapper = new LambdaQueryWrapper<>();
        scoreLambdaQueryWrapper.eq(Score::getId,id);
        List<Score> list = scoreService.list(scoreLambdaQueryWrapper);

        if (!list.isEmpty()){
            return Result.success(list);
        }else {
            return Result.error("查询id为"+id+"的学生成绩信息失败");
        }
    }

    /**
     * 查看所有的学生成绩信息
     * @return
     */
    @GetMapping("/listAll")
    @Operation(summary = "查看所有的学生成绩信息")
    @RequirePermission(value = {"studentScore", "teacherScore"}, logic = RequirePermission.PermissionLogic.OR, message = "您暂时没有查看成绩的权限")
    public Result<List<Score>> listAll(HttpServletRequest request){
        log.info("查看所有的学生成绩信息");
        
        String[] userInfo = getCurrentUserInfo(request);
        String userRole = userInfo[0];
        String userStuId = userInfo[1];
        
        log.info("用户角色: {}, 用户学号: {}", userRole, userStuId);
        
        if ("admin".equals(userRole)) {
            log.info("管理员模式：查看所有成绩");
            // 管理员可以查看所有成绩
            List<Score> list = scoreService.list();
            if (!list.isEmpty()){
                log.info("管理员查询成功，返回 {} 条记录", list.size());
                return Result.success(list);
            }else{
                log.info("管理员查询：暂无成绩数据");
                return Result.success(list);  // 返回空列表而不是错误
            }
        } else if ("teacher".equals(userRole)) {
            log.info("教师模式：查看所有学生成绩（临时解决方案）");
            
            // 临时解决方案：允许教师查看所有成绩
            // TODO: 后续需要修复数据库中的班级信息不一致问题
            List<Score> list = scoreService.list();
            log.info("教师查询成功，返回 {} 条成绩记录", list.size());
            return Result.success(list);
        } else if ("student".equals(userRole)) {
            if (userStuId == null || userStuId.trim().isEmpty()) {
                log.error("学生用户未提供学号信息，请登录");
                return Result.error("请登录以查看您的成绩信息");
            }
            
            try {
                log.info("学生模式：只查看学号 {} 的成绩", userStuId);
                // 学生只能查看自己的成绩
                LambdaQueryWrapper<Score> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(Score::getStuId, Integer.parseInt(userStuId));
                
                // 先查询所有成绩，看看数据库中有哪些数据
                List<Score> allScores = scoreService.list();
                log.info("数据库中总共有 {} 条成绩记录", allScores.size());
                for (Score score : allScores) {
                    log.info("成绩记录: ID={}, 学号={}, 姓名={}", score.getId(), score.getStuId(), score.getStuName());
                }
                
                List<Score> list = scoreService.list(queryWrapper);
                log.info("查询学号 {} 的成绩，找到 {} 条记录", userStuId, list.size());
                
                if (!list.isEmpty()){
                    log.info("学生查询成功，返回 {} 条记录", list.size());
                    return Result.success(list);
                }else{
                    log.warn("未找到学号 {} 的成绩信息", userStuId);
                    return Result.success(list);  // 返回空列表而不是错误
                }
            } catch (NumberFormatException e) {
                log.error("学号格式错误: {}", userStuId, e);
                return Result.error("学号格式错误");
            }
        } else {
            log.error("未知用户角色: {}", userRole);
            return Result.error("权限不足");
        }
    }

    /**
     * 分页查询学生成绩信息
     */
    @GetMapping("/page")
    @Operation(summary = "分页查询")
    @RequirePermission(value = {"studentScore", "teacherScore"}, logic = RequirePermission.PermissionLogic.OR, message = "您暂时没有查看成绩的权限")
    public Result<Page<Score>> page(@RequestParam(defaultValue = "1") Integer current,
                          @RequestParam(defaultValue = "5") Integer size,
                          HttpServletRequest request){
        log.info("分页查询 - current: {}, size: {}", current, size);
        
        String[] userInfo = getCurrentUserInfo(request);
        String userRole = userInfo[0];
        String userStuId = userInfo[1];
        
        log.info("用户角色: {}, 用户学号: {}", userRole, userStuId);
        
        Page<Score> scorePage = new Page<>(current, size);
        
        // 根据用户角色进行权限控制
        if ("admin".equals(userRole)) {
            log.info("管理员模式：查看所有成绩");
            // 管理员可以查看所有成绩
            Page<Score> page = scoreService.page(scorePage);
            if (page.getRecords() != null && !page.getRecords().isEmpty()){
                log.info("管理员查询成功，返回 {} 条记录", page.getRecords().size());
                return Result.success(page);
            }else{
                log.info("管理员分页查询：暂无成绩数据");
                return Result.success(page);  // 返回空页面而不是错误
            }
        } else if ("teacher".equals(userRole)) {
            log.info("教师模式：查看本班级学生成绩");
            
            if (userStuId == null || userStuId.trim().isEmpty()) {
                log.error("教师用户未提供工号信息");
                return Result.error("请登录以查看成绩信息");
            }
            
            try {
                // 1. 根据工号查询教师信息，获取其所教班级
                LambdaQueryWrapper<Teacher> teacherQuery = new LambdaQueryWrapper<>();
                teacherQuery.eq(Teacher::getTeaId, userStuId);
                Teacher teacher = teacherService.getOne(teacherQuery);
                
                if (teacher == null) {
                    log.error("未找到工号为 {} 的教师信息", userStuId);
                    return Result.error("未找到教师信息，请联系管理员");
                }
                
                String teacherClass = teacher.getTeaCalss();
                if (teacherClass == null || teacherClass.trim().isEmpty()) {
                    log.warn("教师 {} 未设置所教班级", userStuId);
                    return Result.error("您未设置所教班级，请联系管理员配置");
                }
                
                log.info("教师 {} 所教班级: {}", userStuId, teacherClass);
                
                // 2. 查询该班级的所有学生
                LambdaQueryWrapper<Student> studentQuery = new LambdaQueryWrapper<>();
                studentQuery.eq(Student::getStuClass, teacherClass);
                List<Student> students = studentService.list(studentQuery);
                
                if (students.isEmpty()) {
                    log.warn("班级 {} 没有学生", teacherClass);
                    return Result.success(new Page<>(current, size)); // 返回空页面
                }
                
                // 3. 提取学生学号列表
                List<Integer> studentIds = students.stream()
                    .map(student -> Integer.parseInt(student.getStuId()))
                    .collect(Collectors.toList());
                
                log.info("班级 {} 共有 {} 名学生", teacherClass, studentIds.size());
                
                // 4. 分页查询所有成绩（临时解决方案）
                Page<Score> page = scoreService.page(scorePage);
                
                log.info("教师分页查询成功，返回 {} 条成绩记录", page.getRecords().size());
                return Result.success(page);
                
            } catch (NumberFormatException e) {
                log.error("学号格式转换错误", e);
                return Result.error("数据格式错误");
            } catch (Exception e) {
                log.error("分页查询教师班级成绩时发生错误", e);
                return Result.error("查询失败：" + e.getMessage());
            }
        } else if ("student".equals(userRole)) {
            log.info("学生模式：只查看学号 {} 的成绩", userStuId);
            // 学生只能查看自己的成绩
            LambdaQueryWrapper<Score> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Score::getStuId, Integer.parseInt(userStuId));
            Page<Score> page = scoreService.page(scorePage, queryWrapper);
            if (page.getRecords() != null && !page.getRecords().isEmpty()){
                log.info("学生查询成功，返回 {} 条记录", page.getRecords().size());
                return Result.success(page);
            }else{
                log.warn("未找到学号 {} 的成绩信息", userStuId);
                return Result.error("未找到学号为 " + userStuId + " 的成绩信息");
            }
        } else if ("student".equals(userRole) && userStuId == null) {
            log.error("学生用户未提供学号信息，请登录");
            return Result.error("请登录以查看您的成绩信息");
        } else {
            log.error("未知用户角色: {}", userRole);
            return Result.error("权限不足");
        }
    }

    @GetMapping("/sumScore")
    @Operation(summary = "计算学生成绩的平均分")
    public Result<String> sumScore(@RequestParam String name){
        log.info("计算学生{}成绩的平均分",name);
        Integer i = scoreService.sumScore(name);
        if (i != 0){
            return Result.success("平均分为："+i);
        }else {
            return Result.error("计算失败！");
        }
    }

    @GetMapping("/calculateAverages")
    @Operation(summary = "计算成绩统计信息")
    @RequirePermission(value = "studentScore", message = "您暂时没有查看成绩统计的权限")
    public Result<List<ScoreStatistics>> calculateAverages(@RequestParam(required = false) Long studentId) {
        try {
            log.info("开始计算成绩统计信息, studentId: {}", studentId);
            List<ScoreStatistics> statistics;
            if (studentId != null) {
                // 获取指定学生的成绩统计
                statistics = scoreService.calculateStudentAverages(studentId);
            } else {
                // 获取所有学生的成绩统计
                statistics = scoreService.calculateAllAverages();
            }
            
            if (statistics.isEmpty()) {
                log.warn("未找到可计算的成绩数据");
                return Result.error("未找到可计算的成绩数据");
            }
            
            log.info("成功计算成绩统计信息，共 {} 条记录", statistics.size());
            return Result.success(statistics);
        } catch (Exception e) {
            log.error("计算成绩统计失败", e);
            return Result.error("计算成绩统计失败：" + e.getMessage());
        }
    }

@GetMapping("/calculateScore")
@Operation(summary = "学生学分绩计算")
@RequirePermission(value = "studentScore", message = "您暂时没有查看成绩统计的权限")
    public Result<Object> creditScoreCalculation(@RequestParam(required = false) Integer stuId){
        log.info("学号为{}的学生的学分绩计算",stuId);
        float scoreStatistics = 0;

        if (stuId != null) {
            scoreStatistics = scoreService.creditScoreCalculation(stuId);
        }

        if (scoreStatistics == 0){
            log.warn("未找到可计算的成绩数据");
            return Result.error("未找到可计算的成绩数据");
        }
        log.info("成功计算学分绩统计信息，学分绩为{}", scoreStatistics);
        return  Result.success(scoreStatistics);
    }
    
    /**
     * 手动更新所有学生的学分绩字段
     */
    @PostMapping("/updateAllCreditScores")
    @Operation(summary = "更新所有学生的学分绩")
    @RequirePermission(value = {"teacherScore", "teacherAdmin"}, message = "您暂时没有更新成绩的权限")
    public Result<String> updateAllCreditScores(HttpServletRequest request) {
        try {
            log.info("开始更新所有学生的学分绩");
            scoreService.updateAllCreditScores();
            return Result.success("所有学生的学分绩更新成功");
        } catch (Exception e) {
            log.error("更新学分绩失败", e);
            return Result.error("更新学分绩失败：" + e.getMessage());
        }
    }
    
    /**
     * 调试接口：检查用户信息和数据库数据
     */
    @GetMapping("/debug")
    @Operation(summary = "调试接口")
    public Result<Object> debug(HttpServletRequest request) {
        try {
            // 获取用户信息
            String[] userInfo = getCurrentUserInfo(request);
            String userRole = userInfo[0];
            String userStuId = userInfo[1];
            
            Map<String, Object> debugInfo = new HashMap<>();
            debugInfo.put("userRole", userRole);
            debugInfo.put("userStuId", userStuId);
            
            // 如果是教师，检查教师信息和班级
            if ("teacher".equals(userRole) && userStuId != null) {
                LambdaQueryWrapper<Teacher> teacherQuery = new LambdaQueryWrapper<>();
                teacherQuery.eq(Teacher::getTeaId, userStuId);
                Teacher teacher = teacherService.getOne(teacherQuery);
                debugInfo.put("teacherInfo", teacher);
                
                if (teacher != null && teacher.getTeaCalss() != null) {
                    // 查询该班级的学生
                    LambdaQueryWrapper<Student> studentQuery = new LambdaQueryWrapper<>();
                    studentQuery.eq(Student::getStuClass, teacher.getTeaCalss());
                    List<Student> students = studentService.list(studentQuery);
                    debugInfo.put("classStudents", students);
                    
                    // 查询该班级学生的成绩
                    if (!students.isEmpty()) {
                        List<Integer> studentIds = students.stream()
                            .map(student -> Integer.parseInt(student.getStuId()))
                            .collect(Collectors.toList());
                        
                        LambdaQueryWrapper<Score> scoreQuery = new LambdaQueryWrapper<>();
                        scoreQuery.in(Score::getStuId, studentIds);
                        List<Score> scores = scoreService.list(scoreQuery);
                        debugInfo.put("classScores", scores);
                    }
                }
            }
            
            // 查询所有教师信息
            List<Teacher> allTeachers = teacherService.list();
            debugInfo.put("allTeachers", allTeachers);
            
            // 查询所有学生信息（限制前10个）
            LambdaQueryWrapper<Student> allStudentQuery = new LambdaQueryWrapper<>();
            allStudentQuery.last("LIMIT 10");
            List<Student> someStudents = studentService.list(allStudentQuery);
            debugInfo.put("someStudents", someStudents);
            
            // 查询所有成绩信息（限制前10个）
            LambdaQueryWrapper<Score> allScoreQuery = new LambdaQueryWrapper<>();
            allScoreQuery.last("LIMIT 10");
            List<Score> someScores = scoreService.list(allScoreQuery);
            debugInfo.put("someScores", someScores);
            
            return Result.success(debugInfo);
        } catch (Exception e) {
            log.error("调试接口执行失败", e);
            return Result.error("调试失败：" + e.getMessage());
        }
    }
}
